package org.jeecg.modules.xl.order.utils;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.modules.system.controller.SysDictController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * 字典数据获取工具
 *
 */
@Slf4j
@Component
public class DictUtils {

    @Autowired
    private RedisUtil redisUtil;
    @Resource
    private SysDictController dictController;

    //所有字典数据
    private static Map<String, List<DictModel>> dictMap;

    /**
     * 初始化字典数据
     */
    public void initDictMap(){
        //判断缓存是否存在
        if (redisUtil.hasKey(CacheConstant.SYS_DICT_CACHE)) {
            //没有缓存，则加载缓存
            if (dictMap == null){
                Object dictRedis = redisUtil.get(CacheConstant.SYS_DICT_CACHE);
                //通过json转为对象
                String jsonString = JSON.toJSONString(dictRedis);

                dictMap = JSON.parseObject(jsonString,Map.class);
            }

        }else {
            //请求接口获取最新字典
            Result<Map<String, List<DictModel>>> result = dictController.queryAllDictItems(null);

            //判断是否请求成功
            if (result.getCode() == 200) {
                //存入缓存 6小时过期
                redisUtil.set(CacheConstant.SYS_DICT_CACHE,result.getResult(), 60 * 60 * 6);
                //重新赋值 字典数据
                dictMap = result.getResult();
            } else {
                throw new JeecgBootException(result.getMessage());
            }
        }
    }

    /**
     * 获取字典数据
     * @return
     */
    public Map<String, List<DictModel>> getDictMap(){
        //初始化
        initDictMap();

        return dictMap;
    }

    /**
     * 根据字典编号 获取字典数据
     * @return
     */
    public List<DictModel> getDictMapByCode(String code){
        //初始化
        initDictMap();

        // 使用 Jackson 库将 JSON 字符串转换为 Map
        ObjectMapper objectMapper = new ObjectMapper();
        List<DictModel> dictModels = objectMapper.convertValue(dictMap.get(code), objectMapper.getTypeFactory().constructCollectionType(List.class, DictModel.class));

        return dictModels;
    }


    /**
     * 根据字典编号和 字典值获取字典标题
     * @param code          字典编号
     * @param dictValue     字典值
     * @return
     */
    public String getDictTitle(String code,String dictValue){
        if (StringUtils.isBlank(dictValue)){
            return "";
        }
        //初始化
        initDictMap();
        // 使用 Jackson 库将 JSON 字符串转换为 Map
        List<DictModel> dictModels = getDictMapByCode(code);
        for (DictModel dictModel : dictModels) {
            if (dictModel.getValue().equals(dictValue)) {
                return dictModel.getLabel();
            }
        }
        return "";
    }

    /**
     * 根据字典编号和 字典标题获取字典值
     * @param code          字典编号
     * @param dictTitle     字典标题
     * @return
     */
    public String getDictValue(String code,String dictTitle){
        if (StringUtils.isBlank(dictTitle)){
            return "";
        }
        //初始化
        initDictMap();
        // 使用 Jackson 库将 JSON 字符串转换为 Map
        List<DictModel> dictModels = getDictMapByCode(code);
        for (DictModel dictModel : dictModels) {
            if (dictModel.getTitle().equals(dictTitle)) {
                return dictModel.getValue();
            }
        }
        return "";
    }

}
